जावास्क्रिप्ट एसिंक जेनरेटर हेल्पर्स: स्ट्रीम निर्माण और प्रबंधन में महारत हासिल करना

जावास्क्रिप्ट में एसिंक्रोनस प्रोग्रामिंग पिछले कुछ वर्षों में काफी विकसित हुई है। एसिंक जेनरेटर और एसिंक इटरेटर्स की शुरुआत के साथ, डेवलपर्स ने एसिंक्रोनस डेटा की धाराओं को संभालने के लिए शक्तिशाली उपकरण प्राप्त किए। अब, जावास्क्रिप्ट एसिंक जेनरेटर हेल्पर्स इन क्षमताओं को और बढ़ाते हैं, जो एसिंक्रोनस डेटा स्ट्रीम बनाने, रूपांतरित करने और प्रबंधित करने का एक अधिक सुव्यवस्थित और अभिव्यंजक तरीका प्रदान करते हैं। यह गाइड एसिंक जेनरेटर हेल्पर्स के मूल सिद्धांतों की पड़ताल करता है, उनकी कार्यक्षमताओं में गहराई से उतरता है, और स्पष्ट उदाहरणों के साथ उनके व्यावहारिक अनुप्रयोगों को प्रदर्शित करता है।

एसिंक जेनरेटर और इटरेटर्स को समझना

एसिंक जेनरेटर हेल्पर्स में जाने से पहले, एसिंक जेनरेटर और एसिंक इटरेटर्स की अंतर्निहित अवधारणाओं को समझना महत्वपूर्ण है।

एसिंक जेनरेटर

एक एसिंक जेनरेटर एक फ़ंक्शन है जिसे रोका और फिर से शुरू किया जा सकता है, जो एसिंक्रोनस रूप से मान उत्पन्न करता है। यह आपको मुख्य थ्रेड को ब्लॉक किए बिना, समय के साथ मानों का एक क्रम उत्पन्न करने की अनुमति देता है। एसिंक जेनरेटर async function* सिंटैक्स का उपयोग करके परिभाषित किए जाते हैं।

उदाहरण:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // एसिंक्रोनस ऑपरेशन का अनुकरण करें
    yield i;
  }
}

// उपयोग
const sequence = generateSequence(1, 5);

एसिंक इटरेटर्स

एक एसिंक इटरेटर एक ऑब्जेक्ट है जो एक next() मेथड प्रदान करता है, जो एक प्रॉमिस लौटाता है जो एक ऑब्जेक्ट में रिजॉल्व होता है जिसमें अनुक्रम में अगला मान और एक done प्रॉपर्टी होती है जो यह दर्शाती है कि अनुक्रम समाप्त हो गया है या नहीं। एसिंक इटरेटर्स का उपयोग for await...of लूप का उपयोग करके किया जाता है।

उदाहरण:

async function* generateSequence(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500));
    yield i;
  }
}

async function consumeSequence() {
  const sequence = generateSequence(1, 5);
  for await (const value of sequence) {
    console.log(value);
  }
}

consumeSequence();

एसिंक जेनरेटर हेल्पर्स का परिचय

एसिंक जेनरेटर हेल्पर्स मेथड्स का एक सेट है जो एसिंक जेनरेटर प्रोटोटाइप की कार्यक्षमता का विस्तार करता है। वे एसिंक्रोनस डेटा स्ट्रीम में हेरफेर करने के सुविधाजनक तरीके प्रदान करते हैं, जिससे कोड अधिक पठनीय और रखरखाव योग्य हो जाता है। ये हेल्पर्स आलसी तरीके से काम करते हैं, जिसका अर्थ है कि वे केवल तभी डेटा संसाधित करते हैं जब इसकी आवश्यकता होती है, जिससे प्रदर्शन में सुधार हो सकता है।

निम्नलिखित एसिंक जेनरेटर हेल्पर्स आमतौर पर उपलब्ध होते हैं (जावास्क्रिप्ट वातावरण और पॉलीफ़िल्स के आधार पर):

• map
• filter
• take
• drop
• flatMap
• reduce
• toArray
• forEach

एसिंक जेनरेटर हेल्पर्स का विस्तृत अन्वेषण

1. `map()`

map() हेल्पर एक प्रदान किए गए फ़ंक्शन को लागू करके एसिंक्रोनस अनुक्रम में प्रत्येक मान को रूपांतरित करता है। यह एक नया एसिंक जेनरेटर लौटाता है जो रूपांतरित मान उत्पन्न करता है।

सिंटेक्स:

asyncGenerator.map(callback)

उदाहरण: संख्याओं की एक स्ट्रीम को उनके वर्गों में बदलना।

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const squares = numbers.map(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100)); // एसिंक्रोनस ऑपरेशन का अनुकरण करें
    return num * num;
  });

  for await (const square of squares) {
    console.log(square);
  }
}

processNumbers();

वास्तविक उपयोग का मामला: कल्पना कीजिए कि आप कई एपीआई से उपयोगकर्ता डेटा प्राप्त कर रहे हैं और डेटा को एक सुसंगत प्रारूप में बदलने की आवश्यकता है। map() का उपयोग प्रत्येक उपयोगकर्ता ऑब्जेक्ट पर एसिंक्रोनस रूप से एक ट्रांसफॉर्मेशन फ़ंक्शन लागू करने के लिए किया जा सकता है।

async function* fetchUsersFromMultipleAPIs(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const response = await fetch(endpoint);
    const data = await response.json();
    for (const user of data) {
      yield user;
    }
  }
}

async function processUsers() {
  const apiEndpoints = [
    'https://api.example.com/users1',
    'https://api.example.com/users2'
  ];

  const users = fetchUsersFromMultipleAPIs(apiEndpoints);

  const normalizedUsers = users.map(async (user) => {
    // उपयोगकर्ता डेटा प्रारूप को सामान्य करें
    return {
      id: user.userId || user.id,
      name: user.fullName || user.name,
      email: user.emailAddress || user.email
    };
  });

  for await (const normalizedUser of normalizedUsers) {
    console.log(normalizedUser);
  }
}

2. `filter()`

filter() हेल्पर एक नया एसिंक जेनरेटर बनाता है जो मूल अनुक्रम से केवल उन मानों को उत्पन्न करता है जो प्रदान की गई शर्त को पूरा करते हैं। यह आपको परिणामी स्ट्रीम में चुनिंदा रूप से मान शामिल करने की अनुमति देता है।

सिंटेक्स:

asyncGenerator.filter(callback)

उदाहरण: संख्याओं की एक स्ट्रीम को फ़िल्टर करके केवल सम संख्याएँ शामिल करना।

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 10);
  const evenNumbers = numbers.filter(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return num % 2 === 0;
  });

  for await (const evenNumber of evenNumbers) {
    console.log(evenNumber);
  }
}

processNumbers();

वास्तविक उपयोग का मामला: लॉग प्रविष्टियों की एक स्ट्रीम को संसाधित करना और उनकी गंभीरता के स्तर के आधार पर प्रविष्टियों को फ़िल्टर करना। उदाहरण के लिए, केवल त्रुटियों और चेतावनियों को संसाधित करना।

async function* readLogFile(filePath) {
  // एक लॉग फ़ाइल को लाइन दर लाइन एसिंक्रोनस रूप से पढ़ने का अनुकरण करें
  const logEntries = [
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' },
    { timestamp: '...', level: 'WARNING', message: '...' },
    { timestamp: '...', level: 'INFO', message: '...' },
    { timestamp: '...', level: 'ERROR', message: '...' }
  ];

  for (const entry of logEntries) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield entry;
  }
}

async function processLogs() {
  const logEntries = readLogFile('path/to/log/file.log');
  const errorAndWarningLogs = logEntries.filter(async (entry) => {
    return entry.level === 'ERROR' || entry.level === 'WARNING';
  });

  for await (const log of errorAndWarningLogs) {
    console.log(log);
  }
}

3. `take()`

take() हेल्पर एक नया एसिंक जेनरेटर बनाता है जो मूल अनुक्रम से केवल पहले n मान उत्पन्न करता है। यह एक संभावित अनंत या बहुत बड़ी स्ट्रीम से संसाधित की जाने वाली वस्तुओं की संख्या को सीमित करने के लिए उपयोगी है।

सिंटेक्स:

asyncGenerator.take(n)

उदाहरण: संख्याओं की एक स्ट्रीम से पहली 3 संख्याएँ लेना।

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);
  const firstThree = numbers.take(3);

  for await (const num of firstThree) {
    console.log(num);
  }
}

processNumbers();

वास्तविक उपयोग का मामला: एक एसिंक्रोनस खोज एपीआई से शीर्ष 5 खोज परिणाम प्रदर्शित करना।

async function* search(query) {
  // एपीआई से खोज परिणाम लाने का अनुकरण करें
  const results = [
    { title: 'Result 1', url: '...' },
    { title: 'Result 2', url: '...' },
    { title: 'Result 3', url: '...' },
    { title: 'Result 4', url: '...' },
    { title: 'Result 5', url: '...' },
    { title: 'Result 6', url: '...' }
  ];

  for (const result of results) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield result;
  }
}

async function displayTopSearchResults(query) {
  const searchResults = search(query);
  const top5Results = searchResults.take(5);

  for await (const result of top5Results) {
    console.log(result);
  }
}

4. `drop()`

drop() हेल्पर एक नया एसिंक जेनरेटर बनाता है जो मूल अनुक्रम से पहले n मानों को छोड़ देता है और शेष मानों को उत्पन्न करता है। यह take() के विपरीत है और एक स्ट्रीम के शुरुआती हिस्सों को अनदेखा करने के लिए उपयोगी है।

सिंटेक्स:

asyncGenerator.drop(n)

उदाहरण: संख्याओं की एक स्ट्रीम से पहली 2 संख्याएँ छोड़ना।

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const remainingNumbers = numbers.drop(2);

  for await (const num of remainingNumbers) {
    console.log(num);
  }
}

processNumbers();

वास्तविक उपयोग का मामला: एपीआई से प्राप्त एक बड़े डेटासेट के माध्यम से पेजिनेटिंग, पहले से प्रदर्शित परिणामों को छोड़ना।

async function* fetchData(url, pageSize, pageNumber) {
  const offset = (pageNumber - 1) * pageSize;
  // ऑफसेट के साथ डेटा लाने का अनुकरण करें
  const data = [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' },
    { id: 3, name: 'Item 3' },
    { id: 4, name: 'Item 4' },
    { id: 5, name: 'Item 5' },
    { id: 6, name: 'Item 6' },
    { id: 7, name: 'Item 7' },
    { id: 8, name: 'Item 8' }
  ];

  const pageData = data.slice(offset, offset + pageSize);

  for (const item of pageData) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield item;
  }
}

async function displayPage(pageNumber) {
  const pageSize = 3;
  const allData = fetchData('api/data', pageSize, pageNumber);
  const page = allData.drop((pageNumber - 1) * pageSize);  // पिछले पृष्ठों से आइटम छोड़ें

  const results = page.take(pageSize);


  for await (const item of results) {
    console.log(item);
  }
}

// उदाहरण उपयोग
displayPage(2);

5. `flatMap()`

flatMap() हेल्पर एसिंक्रोनस अनुक्रम में प्रत्येक मान को एक फ़ंक्शन लागू करके रूपांतरित करता है जो एक एसिंक इटरेबल लौटाता है। फिर यह परिणामी एसिंक इटरेबल को एक एकल एसिंक जेनरेटर में समतल करता है। यह प्रत्येक मान को मानों की एक स्ट्रीम में बदलने और फिर उन स्ट्रीमों को संयोजित करने के लिए उपयोगी है।

सिंटेक्स:

asyncGenerator.flatMap(callback)

उदाहरण: वाक्यों की एक स्ट्रीम को शब्दों की एक स्ट्रीम में बदलना।

async function* generateSentences() {
  const sentences = [
    'This is the first sentence.',
    'This is the second sentence.',
    'This is the third sentence.'
  ];

  for (const sentence of sentences) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield sentence;
  }
}

async function* stringToWords(sentence) {
    const words = sentence.split(' ');
    for (const word of words) {
        await new Promise(resolve => setTimeout(resolve, 50));
        yield word;
    }
}

async function processSentences() {
  const sentences = generateSentences();
  const words = sentences.flatMap(async (sentence) => {
      return stringToWords(sentence);
  });

  for await (const word of words) {
    console.log(word);
  }
}

processSentences();

वास्तविक उपयोग का मामला: कई ब्लॉग पोस्ट के लिए टिप्पणियां प्राप्त करना और उन्हें प्रसंस्करण के लिए एक ही स्ट्रीम में संयोजित करना।

async function* fetchBlogPostIds() {
  const blogPostIds = [1, 2, 3]; // एपीआई से ब्लॉग पोस्ट आईडी लाने का अनुकरण करें
  for (const id of blogPostIds) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield id;
  }
}

async function* fetchCommentsForPost(postId) {
  // एपीआई से ब्लॉग पोस्ट के लिए टिप्पणियां लाने का अनुकरण करें
  const comments = [
    { postId: postId, text: `Comment 1 for post ${postId}` },
    { postId: postId, text: `Comment 2 for post ${postId}` }
  ];
  for (const comment of comments) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield comment;
  }
}

async function processComments() {
  const postIds = fetchBlogPostIds();
  const allComments = postIds.flatMap(async (postId) => {
    return fetchCommentsForPost(postId);
  });

  for await (const comment of allComments) {
    console.log(comment);
  }
}

6. `reduce()`

reduce() हेल्पर एक संचायक और एसिंक जेनरेटर के प्रत्येक मान (बाएं से दाएं) के खिलाफ एक फ़ंक्शन लागू करता है ताकि इसे एक ही मान में कम किया जा सके। यह एक एसिंक्रोनस स्ट्रीम से डेटा एकत्र करने के लिए उपयोगी है।

सिंटेक्स:

asyncGenerator.reduce(callback, initialValue)

उदाहरण: एक स्ट्रीम में संख्याओं का योग ज्ञात करना।

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const sum = await numbers.reduce(async (accumulator, num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    return accumulator + num;
  }, 0);

  console.log('Sum:', sum);
}

processNumbers();

वास्तविक उपयोग का मामला: एपीआई कॉलों की एक श्रृंखला के औसत प्रतिक्रिया समय की गणना करना।

async function* fetchResponseTimes(apiEndpoints) {
  for (const endpoint of apiEndpoints) {
    const startTime = Date.now();
    try {
      await fetch(endpoint);
      const endTime = Date.now();
      const responseTime = endTime - startTime;
      await new Promise(resolve => setTimeout(resolve, 50));
      yield responseTime;
    } catch (error) {
      console.error(`Error fetching ${endpoint}: ${error}`);
      yield 0; // या त्रुटि को उचित रूप से संभालें
    }
  }
}

async function calculateAverageResponseTime() {
  const apiEndpoints = [
    'https://api.example.com/endpoint1',
    'https://api.example.com/endpoint2',
    'https://api.example.com/endpoint3'
  ];
  const responseTimes = fetchResponseTimes(apiEndpoints);

  let count = 0;
  const sum = await responseTimes.reduce(async (accumulator, time) => {
    count++;
    return accumulator + time;
  }, 0);

  const average = count > 0 ? sum / count : 0;
  console.log(`Average response time: ${average} ms`);
}

7. `toArray()`

toArray() हेल्पर एसिंक जेनरेटर का उपभोग करता है और एक प्रॉमिस लौटाता है जो जेनरेटर द्वारा उत्पन्न सभी मानों वाले एक ऐरे में रिजॉल्व होता है। यह तब उपयोगी होता है जब आपको आगे की प्रक्रिया के लिए स्ट्रीम से सभी मानों को एक ही ऐरे में एकत्र करने की आवश्यकता होती है।

सिंटेक्स:

asyncGenerator.toArray()

उदाहरण: एक स्ट्रीम से संख्याओं को एक ऐरे में एकत्र करना।

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  const numberArray = await numbers.toArray();

  console.log('Number Array:', numberArray);
}

processNumbers();

वास्तविक उपयोग का मामला: क्लाइंट-साइड फ़िल्टरिंग या सॉर्टिंग के लिए एक पेजिनेटेड एपीआई से सभी आइटम को एक ही ऐरे में एकत्र करना।

async function* fetchAllItems(apiEndpoint) {
    let pageNumber = 1;
    const pageSize = 100;  // एपीआई की पेजिनेशन सीमाओं के आधार पर समायोजित करें

    while (true) {
        const url = `${apiEndpoint}?page=${pageNumber}&pageSize=${pageSize}`;
        const response = await fetch(url);
        const data = await response.json();

        if (!data || data.length === 0) {
            break; // और डेटा नहीं है
        }

        for (const item of data) {
            await new Promise(resolve => setTimeout(resolve, 50));
            yield item;
        }

        pageNumber++;
    }
}

async function processAllItems() {
    const apiEndpoint = 'https://api.example.com/items';
    const allItems = fetchAllItems(apiEndpoint);
    const itemsArray = await allItems.toArray();

    console.log(`Fetched ${itemsArray.length} items.`);
    // `itemsArray` पर आगे की प्रक्रिया की जा सकती है
}

8. `forEach()`

forEach() हेल्पर एसिंक जेनरेटर में प्रत्येक मान के लिए एक बार एक प्रदान किया गया फ़ंक्शन निष्पादित करता है। अन्य हेल्पर्स के विपरीत, forEach() एक नया एसिंक जेनरेटर नहीं लौटाता है; इसका उपयोग प्रत्येक मान पर साइड इफेक्ट करने के लिए किया जाता है।

सिंटेक्स:

asyncGenerator.forEach(callback)

उदाहरण: एक स्ट्रीम में प्रत्येक संख्या को कंसोल पर लॉग करना।

async function* generateNumbers(start, end) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 200));
    yield i;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1, 5);
  await numbers.forEach(async (num) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Number:', num);
  });
}

processNumbers();

वास्तविक उपयोग का मामला: एक स्ट्रीम से डेटा संसाधित होने पर उपयोगकर्ता इंटरफ़ेस पर रीयल-टाइम अपडेट भेजना।

async function* fetchRealTimeData(dataSource) {
    //रीयल-टाइम डेटा (जैसे स्टॉक की कीमतें) लाने का अनुकरण करें।
    const dataStream = [
      { timestamp: new Date(), price: 100 },
      { timestamp: new Date(), price: 101 },
      { timestamp: new Date(), price: 102 }
    ];
    for (const dataPoint of dataStream) {
      await new Promise(resolve => setTimeout(resolve, 500));
      yield dataPoint;
    }
}

async function updateUI() {
  const realTimeData = fetchRealTimeData('stock-api');
  await realTimeData.forEach(async (data) => {
    //UI को अपडेट करने का अनुकरण करें
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log(`Updating UI with data: ${JSON.stringify(data)}`);
    // UI को वास्तव में अपडेट करने के लिए कोड यहाँ जाएगा।
  });
}

जटिल डेटा पाइपलाइनों के लिए एसिंक जेनरेटर हेल्पर्स का संयोजन

एसिंक जेनरेटर हेल्पर्स की असली शक्ति उनकी एक साथ श्रृंखलाबद्ध होने की क्षमता से आती है ताकि जटिल डेटा पाइपलाइन बनाई जा सके। यह आपको एक संक्षिप्त और पठनीय तरीके से एक एसिंक्रोनस स्ट्रीम पर कई परिवर्तन और संचालन करने की अनुमति देता है।

उदाहरण: संख्याओं की एक स्ट्रीम को फ़िल्टर करके केवल सम संख्याएँ शामिल करना, फिर उनका वर्ग करना, और अंत में पहले 3 परिणाम लेना।

async function* generateNumbers(start) {
  let i = start;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

async function processNumbers() {
  const numbers = generateNumbers(1);

  const processedNumbers = numbers
    .filter(async (num) => num % 2 === 0)
    .map(async (num) => num * num)
    .take(3);

  for await (const num of processedNumbers) {
    console.log(num);
  }
}

processNumbers();

वास्तविक उपयोग का मामला: उपयोगकर्ता डेटा प्राप्त करना, उनके स्थान के आधार पर उपयोगकर्ताओं को फ़िल्टर करना, उनके डेटा को केवल प्रासंगिक फ़ील्ड शामिल करने के लिए बदलना, और फिर मानचित्र पर पहले 10 उपयोगकर्ताओं को प्रदर्शित करना।

async function* fetchUsers() {
  // डेटाबेस या एपीआई से उपयोगकर्ताओं को लाने का अनुकरण करें
  const users = [
    { id: 1, name: 'John Doe', location: 'New York', email: 'john.doe@example.com' },
    { id: 2, name: 'Jane Smith', location: 'London', email: 'jane.smith@example.com' },
    { id: 3, name: 'Ken Tan', location: 'Singapore', email: 'ken.tan@example.com' },
    { id: 4, name: 'Alice Jones', location: 'New York', email: 'alice.jones@example.com' },
    { id: 5, name: 'Bob Williams', location: 'London', email: 'bob.williams@example.com' },
    { id: 6, name: 'Siti Rahman', location: 'Singapore', email: 'siti.rahman@example.com' },
    { id: 7, name: 'Ahmed Khan', location: 'Dubai', email: 'ahmed.khan@example.com' },
    { id: 8, name: 'Maria Garcia', location: 'Madrid', email: 'maria.garcia@example.com' },
    { id: 9, name: 'Li Wei', location: 'Shanghai', email: 'li.wei@example.com' },
    { id: 10, name: 'Hans Müller', location: 'Berlin', email: 'hans.muller@example.com' },
    { id: 11, name: 'Emily Chen', location: 'Sydney', email: 'emily.chen@example.com' }
  ];

  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

async function displayUsersOnMap(location, maxUsers) {
  const users = fetchUsers();

  const usersForMap = users
    .filter(async (user) => user.location === location)
    .map(async (user) => ({
      id: user.id,
      name: user.name,
      location: user.location
    }))
    .take(maxUsers);

  console.log(`Displaying up to ${maxUsers} users from ${location} on the map:`);
  for await (const user of usersForMap) {
    console.log(user);
  }
}

// उपयोग के उदाहरण:
displayUsersOnMap('New York', 2);
displayUsersOnMap('London', 5);

पॉलीफ़िल्स और ब्राउज़र समर्थन

एसिंक जेनरेटर हेल्पर्स के लिए समर्थन जावास्क्रिप्ट वातावरण के आधार पर भिन्न हो सकता है। यदि आपको पुराने ब्राउज़रों या वातावरणों का समर्थन करने की आवश्यकता है, तो आपको पॉलीफ़िल्स का उपयोग करने की आवश्यकता हो सकती है। एक पॉलीफ़िल जावास्क्रिप्ट में इसे लागू करके लापता कार्यक्षमता प्रदान करता है। एसिंक जेनरेटर हेल्पर्स के लिए कई पॉलीफ़िल लाइब्रेरी उपलब्ध हैं, जैसे कि core-js।

core-js का उपयोग करके उदाहरण:

// आवश्यक पॉलीफ़िल्स आयात करें
require('core-js/features/async-iterator/map');
require('core-js/features/async-iterator/filter');
// ... अन्य आवश्यक हेल्पर्स आयात करें

त्रुटि प्रबंधन (Error Handling)

एसिंक्रोनस ऑपरेशनों के साथ काम करते समय, त्रुटियों को ठीक से संभालना महत्वपूर्ण है। एसिंक जेनरेटर हेल्पर्स के साथ, हेल्पर्स में उपयोग किए जाने वाले एसिंक्रोनस फ़ंक्शंस के भीतर try...catch ब्लॉक का उपयोग करके त्रुटि प्रबंधन किया जा सकता है।

उदाहरण: map() ऑपरेशन के भीतर डेटा लाते समय त्रुटियों को संभालना।

async function* fetchData(urls) {
  for (const url of urls) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const data = await response.json();
      yield data;
    } catch (error) {
      console.error(`Error fetching data from ${url}: ${error}`);
      yield null; // या त्रुटि को उचित रूप से संभालें, जैसे, एक त्रुटि ऑब्जेक्ट उत्पन्न करके
    }
  }
}

async function processData() {
  const urls = [
    'https://api.example.com/data1',
    'https://api.example.com/data2',
    'https://api.example.com/data3'
  ];

  const dataStream = fetchData(urls);

  const processedData = dataStream.map(async (data) => {
    if (data === null) {
      return null; // त्रुटि का प्रसार करें
    }
    // डेटा को संसाधित करें
    return data;
  });

  for await (const item of processedData) {
    if (item === null) {
      console.log('Skipping item due to error');
      continue;
    }
    console.log('Processed Item:', item);
  }
}

processData();

सर्वोत्तम प्रथाएं और विचार

• आलसी मूल्यांकन (Lazy Evaluation): एसिंक जेनरेटर हेल्पर्स का मूल्यांकन आलसी तरीके से किया जाता है, जिसका अर्थ है कि वे केवल अनुरोध किए जाने पर ही डेटा संसाधित करते हैं। यह प्रदर्शन में सुधार कर सकता है, खासकर जब बड़े डेटासेट के साथ काम कर रहे हों।
• त्रुटि प्रबंधन: हेल्पर्स में उपयोग किए जाने वाले एसिंक्रोनस फ़ंक्शंस के भीतर हमेशा त्रुटियों को ठीक से संभालें।
• पॉलीफ़िल्स: पुराने ब्राउज़रों या वातावरणों का समर्थन करने के लिए आवश्यक होने पर पॉलीफ़िल्स का उपयोग करें।
• पठनीयता: अपने कोड को अधिक पठनीय और रखरखाव योग्य बनाने के लिए वर्णनात्मक चर नामों और टिप्पणियों का उपयोग करें।
• प्रदर्शन: कई हेल्पर्स को एक साथ जोड़ने के प्रदर्शन संबंधी प्रभावों से सावधान रहें। जबकि आलस्य मदद करता है, अत्यधिक श्रृंखलाबद्धता अभी भी ओवरहेड ला सकती है।

निष्कर्ष

जावास्क्रिप्ट एसिंक जेनरेटर हेल्पर्स एसिंक्रोनस डेटा स्ट्रीम बनाने, बदलने और प्रबंधित करने का एक शक्तिशाली और सुरुचिपूर्ण तरीका प्रदान करते हैं। इन हेल्पर्स का लाभ उठाकर, डेवलपर्स जटिल एसिंक्रोनस ऑपरेशनों को संभालने के लिए अधिक संक्षिप्त, पठनीय और रखरखाव योग्य कोड लिख सकते हैं। एसिंक जेनरेटर और इटरेटर्स के मूल सिद्धांतों को समझना, प्रत्येक हेल्पर की कार्यक्षमताओं के साथ, वास्तविक दुनिया के अनुप्रयोगों में इन उपकरणों का प्रभावी ढंग से उपयोग करने के लिए आवश्यक है। चाहे आप डेटा पाइपलाइन बना रहे हों, रीयल-टाइम डेटा संसाधित कर रहे हों, या एसिंक्रोनस एपीआई प्रतिक्रियाओं को संभाल रहे हों, एसिंक जेनरेटर हेल्पर्स आपके कोड को काफी सरल बना सकते हैं और इसकी समग्र दक्षता में सुधार कर सकते हैं।